package N叉树;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/
 */
public class _589_N叉树的前序遍历 {
    /**
     * 非递归版解题思路：
     * <p>
     * 二叉树的非递归遍历是每次将当前结点右孩子节点和左孩子节点依次压入栈中，注意是先右后左。
     * 然后将出栈节点输出，并且在将其右子节点和左子节点压入栈中。
     * 推广到N叉树，就是将当前结点的孩子节点由右到左依次压入栈中。
     * 然后将出栈节点输出，并且将其孩子节点依次压入栈中。
     * 时间复杂度O（N），空间复杂度O（N）
     */
    public List<Integer> preorder2(Node root) {
        //非递归版
        List<Integer> res = new ArrayList<Integer>();
        Stack<Node> stack = new Stack<Node>();
        if (root == null)
            return res;
        stack.push(root);
        while (!stack.isEmpty()) {
            Node node = stack.pop();
            res.add(node.val);
            for (int i = node.children.size() - 1; i >= 0; i--) {
                stack.add(node.children.get(i));
            }
        }
        return res;
    }

    List<Integer> res = new ArrayList<Integer>();

    public List<Integer> preorder1(Node root) {
        //递归版

        if (root == null)
            return res;
        res.add(root.val);
        for (Node child : root.children) {
            preorder(child);
        }

        return res;
    }


    List<Integer> list = new ArrayList<>();

    public List<Integer> preorder(Node root) {
        if (root == null) return list;
        list.add(root.val);
        return preo(root.children);
    }

    private List<Integer> preo(List<Node> children) {
        if (children == null) return list;
        for (Node child : children) {
            if (child == null) return list;
            list.add(child.val);
            preo(child.children);
        }
        return list;
    }


}
